// pages/consultation-records/index.js - 咨询记录管理页面逻辑
const app = getApp()
const db = wx.cloud.database()
const _ = db.command

Page({
  // 页面的初始数据
  data: {
    records: [], // 咨询记录列表
    dateFilter: '', // 日期筛选条件
    showDetailModal: false, // 是否显示详情模态框
    showEditModal: false, // 是否显示编辑模态框
    currentRecord: null, // 当前选中的咨询记录
    isEditing: false, // 是否处于编辑模式
    studentList: [], // 学生列表数据
    selectedStudent: null, // 当前选中的学生
    mentalStatusOptions: ['良好', '一般', '较差', '严重'], // 心理状态选项
    formData: {
      content: '', // 咨询内容
      conclusion: '', // 咨询结论
      suggestion: '', // 建议
      location: '心理咨询室', // 评测地点
      evaluationTime: '', // 评测时间
      mentalStatus: '', // 心理状态
      notes: '' // 备注
    },
    today: '' // 当前日期，用于日期选择器
  },

  // 返回上一页功能
  goBack: function() {
    wx.navigateBack({
      delta: 1
    });
  },

  // 页面加载时执行的初始化操作
  onLoad: function (options) {
    this.setData({
      today: this.formatDate(new Date())
    })
    this.fetchStudentList() // 获取学生列表
    this.fetchRecords() // 获取咨询记录
  },

  // 下拉刷新页面数据
  onPullDownRefresh: function () {
    this.fetchRecords().then(() => {
      wx.stopPullDownRefresh()
    })
  },

  // 将日期对象格式化为 YYYY-MM-DD 字符串
  formatDate: function (date) {
    const year = date.getFullYear()
    const month = (date.getMonth() + 1).toString().padStart(2, '0')
    const day = date.getDate().toString().padStart(2, '0')
    return `${year}-${month}-${day}`
  },

  // 从数据库获取学生列表
  fetchStudentList: function () {
    wx.showLoading({
      title: '加载中',
    })
    // 查询角色为student的用户
    db.collection('users')
      .where({
        role: 'student'
      })
      .get()
      .then(res => {
        this.setData({
          studentList: res.data
        })
        wx.hideLoading()
      })
      .catch(err => {
        console.error('获取学生列表失败', err)
        wx.hideLoading()
        wx.showToast({
          title: '获取学生列表失败',
          icon: 'none'
        })
      })
  },

  // 从数据库获取咨询记录
  fetchRecords: function () {
    wx.showLoading({
      title: '加载中',
    })
    
    let query = db.collection('consultation_records')
    
    // 如果设置了日期筛选，添加日期范围条件
    if (this.data.dateFilter) {
      const startDate = new Date(this.data.dateFilter)
      startDate.setHours(0, 0, 0, 0)
      
      const endDate = new Date(this.data.dateFilter)
      endDate.setHours(23, 59, 59, 999)
      
      query = query.where({
        createTime: _.gte(startDate).and(_.lte(endDate))
      })
    }
    
    // 执行查询并按创建时间降序排序
    return query
      .orderBy('createTime', 'desc')
      .get()
      .then(res => {
        console.log('获取到咨询记录:', res.data);
        
        // 对每条记录进行处理，获取关联数据
        const recordsPromises = res.data.map(record => {
          // 获取学生用户名，用于后续查询
          const studentName = record.username || record.studentName || '';
          
          // 通过用户名查询users表获取班级信息的辅助函数
          const getUserByUsername = (username) => {
            if (!username) return Promise.resolve(null);
            
            return db.collection('users')
              .where({
                username: username
              })
              .get()
              .then(res => {
                if (res.data && res.data.length > 0) {
                  return res.data[0];
                }
                return null;
              })
              .catch(err => {
                console.error('通过用户名查询用户失败:', err);
                return null;
              });
          };
          
          // 1. 先获取用户信息（包括班级）
          return getUserByUsername(studentName)
            .then(userInfo => {
              console.log('通过用户名找到的用户信息:', userInfo);
              
              // 获取班级信息
              let className = '';
              if (userInfo) {
                if (userInfo.classes && userInfo.classes.length > 0) {
                  className = userInfo.classes.join(', ');
                } else if (userInfo.class) {
                  className = userInfo.class;
                }
              }
              
              // 2. 获取咨询申请记录以获取更多信息
              return db.collection('consultation_requests')
                .where({
                  studentId: record.userId || record.studentId || ''
                })
                .orderBy('createTime', 'desc')
                .limit(1)
                .get()
                .then(requestRes => {
                  let requestInfo = null;
                  if (requestRes.data && requestRes.data.length > 0) {
                    requestInfo = requestRes.data[0];
                  }
                  
                  // 3. 整合所有信息，生成完整的记录对象
                  return {
                    ...record,
                    studentName: studentName || 
                                (userInfo ? userInfo.username : null) || 
                                'student',
                    class: className || '',  // 使用从users表获取的班级信息
                    problemType: (record.problemType || 
                               (requestInfo ? requestInfo.problemType : null) || 
                               '学习压力'),
                    description: record.description || 
                                (requestInfo ? requestInfo.description : '') || '',
                    createTime: this.formatDate(new Date(record.createTime)),
                    evaluationTimeFormatted: record.evaluationTime ? 
                                         this.formatDate(new Date(record.evaluationTime)) : '未设置'
                  };
                })
                .catch(err => {
                  console.error('获取申请记录失败:', err);
                  // 即使获取申请记录失败，也返回基本的记录信息
                  return {
                    ...record,
                    studentName: studentName || 
                                (userInfo ? userInfo.username : null) || 
                                'student',
                    class: className || '',
                    problemType: record.problemType || '学习压力',
                    description: record.description || '',
                    createTime: this.formatDate(new Date(record.createTime)),
                    evaluationTimeFormatted: record.evaluationTime ? 
                                         this.formatDate(new Date(record.evaluationTime)) : '未设置'
                  };
                });
            })
            .catch(err => {
              console.error('获取用户信息失败:', err);
              // 即使获取用户信息失败，也返回基本的记录信息
              return {
                ...record,
                studentName: studentName || 'student',
                class: '',
                problemType: record.problemType || '学习压力',
                description: record.description || '',
                createTime: this.formatDate(new Date(record.createTime)),
                evaluationTimeFormatted: record.evaluationTime ? 
                                     this.formatDate(new Date(record.evaluationTime)) : '未设置'
              };
            });
        });
        
        // 等待所有记录处理完成后更新页面数据
        return Promise.all(recordsPromises)
          .then(processedRecords => {
            console.log('处理后的咨询记录:', processedRecords);
            this.setData({
              records: processedRecords
            });
            wx.hideLoading();
            return processedRecords;
          });
      })
      .catch(err => {
        console.error('获取咨询记录失败', err)
        wx.hideLoading()
        wx.showToast({
          title: '获取咨询记录失败',
          icon: 'none'
        })
      });
  },

  // 处理搜索框输入事件，实时搜索
  onSearchInput: function (e) {
    const keyword = e.detail.value.trim()
    if (keyword === '') {
      // 清空搜索时恢复所有数据
      this.fetchRecords()
      return
    }
    
    // 在本地数据中进行搜索过滤
    const searchResult = this.data.records.filter(record => {
      return record.studentName.includes(keyword) || 
             record.studentId.includes(keyword)
    })
    
    this.setData({
      records: searchResult
    })
  },

  // 处理日期筛选变化，重新获取数据
  onDateFilterChange: function (e) {
    this.setData({
      dateFilter: e.detail.value
    })
    this.fetchRecords()
  },

  // 点击记录卡片，查看详情
  onRecordTap: function (e) {
    const id = e.currentTarget.dataset.id
    const record = this.data.records.find(item => item._id === id)
    
    if (record) {
      // 显示详情模态框
      this.setData({
        currentRecord: record,
        showDetailModal: true
      })
    }
  },

  // 关闭详情模态框
  onCloseDetailModal: function () {
    this.setData({
      showDetailModal: false,
      currentRecord: null
    })
  },

  // 查看学生心理测评结果
  onViewTestResults: function () {
    const userId = this.data.currentRecord.userId
    wx.navigateTo({
      url: `/pages/psychological-test-results/index?userId=${userId}`
    })
  },

  // 点击编辑按钮，进入编辑模式
  onEditTap: function (e) {
    // 由于使用了catchtap，不需要stopPropagation
    // e.stopPropagation() // 阻止冒泡，防止触发onRecordTap
    
    const id = e.currentTarget.dataset.id
    const record = this.data.records.find(item => item._id === id)
    
    if (record) {
      const studentName = record.studentName || 'student';
      const className = record.class || '';
      
      // 查找记录对应的学生信息
      const student = this.data.studentList.find(
        s => (s.username === studentName) || (s.name === studentName)
      ) || {
        name: studentName,
        username: studentName,
        class: className
      };
      
      // 设置表单数据并显示编辑模态框
      this.setData({
        isEditing: true,
        currentRecord: record,
        selectedStudent: student,
        showEditModal: true,
        formData: {
          content: record.content || '',
          conclusion: record.conclusion || '',
          suggestion: record.suggestion || '',
          location: record.location || '心理咨询室',
          evaluationTime: record.evaluationTime ? this.formatDate(new Date(record.evaluationTime)) : '',
          mentalStatus: record.mentalStatus || '',
          notes: record.notes || ''
        }
      })
    }
  },

  // 点击添加记录按钮，显示新增记录模态框
  onAddRecord: function () {
    this.setData({
      isEditing: false,
      currentRecord: null,
      selectedStudent: null,
      formData: {
        content: '',
        conclusion: '',
        suggestion: '',
        location: '心理咨询室',
        evaluationTime: '',
        mentalStatus: '',
        notes: ''
      },
      showEditModal: true
    })
  },

  // 关闭编辑模态框
  onCloseEditModal: function () {
    this.setData({
      showEditModal: false
    })
  },

  // 处理学生选择器变化事件
  onStudentChange: function (e) {
    const index = e.detail.value
    const student = this.data.studentList[index]
    this.setData({
      selectedStudent: student
    })
  },

  // 表单字段输入处理函数 - 咨询内容
  onContentInput: function (e) {
    this.setData({
      'formData.content': e.detail.value
    })
  },
  
  // 表单字段输入处理函数 - 咨询结论
  onConclusionInput: function (e) {
    this.setData({
      'formData.conclusion': e.detail.value
    })
  },
  
  // 表单字段输入处理函数 - 建议
  onSuggestionInput: function (e) {
    this.setData({
      'formData.suggestion': e.detail.value
    })
  },

  // 处理评测时间选择器变化
  onEvaluationTimeChange: function (e) {
    this.setData({
      'formData.evaluationTime': e.detail.value
    })
  },

  // 处理评测地点输入
  onLocationInput: function (e) {
    this.setData({
      'formData.location': e.detail.value
    })
  },

  // 处理心理状态选择器变化
  onMentalStatusChange: function (e) {
    this.setData({
      'formData.mentalStatus': this.data.mentalStatusOptions[e.detail.value]
    })
  },

  // 处理备注输入
  onNotesInput: function (e) {
    this.setData({
      'formData.notes': e.detail.value
    })
  },

  // 提交表单，保存咨询记录
  onSubmitForm: function () {
    // 表单基本验证
    if (!this.data.selectedStudent) {
      wx.showToast({
        title: '请选择学生',
        icon: 'none'
      })
      return
    }
    
    if (!this.data.formData.content.trim()) {
      wx.showToast({
        title: '请输入咨询内容',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({
      title: '保存中',
    })
    
    // 获取当前登录用户信息（咨询师）
    const currentUserInfo = wx.getStorageSync('userInfo');
    if (!currentUserInfo) {
      wx.hideLoading();
      wx.showToast({
        title: '获取用户信息失败，请重新登录',
        icon: 'none'
      });
      return;
    }
    
    // 首先尝试获取学生的咨询申请记录，补充问题信息
    db.collection('consultation_requests')
      .where({
        studentId: this.data.selectedStudent._id
      })
      .orderBy('createTime', 'desc')
      .limit(1)
      .get()
      .then(requestRes => {
        let requestInfo = null;
        if (requestRes.data && requestRes.data.length > 0) {
          requestInfo = requestRes.data[0];
          console.log('找到对应申请记录:', requestInfo);
        }
        
        // 准备表单数据，构建完整的记录对象
        const formData = {
          userId: this.data.selectedStudent._id,
          staffId: currentUserInfo._id || currentUserInfo.openId || currentUserInfo._openid, // 使用本地存储中的用户ID
          username: this.data.selectedStudent.username || this.data.selectedStudent.name, // 直接存储学生姓名
          content: this.data.formData.content,
          conclusion: this.data.formData.conclusion,
          suggestion: this.data.formData.suggestion,
          location: this.data.formData.location || '心理咨询室',
          evaluationTime: this.data.formData.evaluationTime ? new Date(this.data.formData.evaluationTime) : new Date(),
          mentalStatus: this.data.formData.mentalStatus || '一般',
          notes: this.data.formData.notes || '',
          updateTime: new Date()
        }
        
        // 添加班级信息
        if (this.data.selectedStudent.classes && this.data.selectedStudent.classes.length > 0) {
          formData.class = this.data.selectedStudent.classes[0];
        } else if (this.data.selectedStudent.class) {
          formData.class = this.data.selectedStudent.class;
        }
        
        // 如果找到了申请记录，添加相关问题信息
        if (requestInfo) {
          formData.problemType = requestInfo.problemType;
          formData.description = requestInfo.description;
        }
        
        // 根据模式执行新增或更新操作
        if (this.data.isEditing) {
          // 更新已有记录
          db.collection('consultation_records')
            .doc(this.data.currentRecord._id)
            .update({
              data: formData
            })
            .then(() => {
              wx.hideLoading()
              wx.showToast({
                title: '更新成功',
              })
              this.setData({
                showEditModal: false
              })
              this.fetchRecords() // 刷新列表数据
            })
            .catch(err => {
              console.error('更新咨询记录失败', err)
              wx.hideLoading()
              wx.showToast({
                title: '更新失败',
                icon: 'none'
              })
            })
        } else {
          // 添加创建时间字段
          formData.createTime = new Date()
          
          // 新增记录
          db.collection('consultation_records')
            .add({
              data: formData
            })
            .then(() => {
              wx.hideLoading()
              wx.showToast({
                title: '添加成功',
              })
              this.setData({
                showEditModal: false
              })
              this.fetchRecords() // 刷新列表数据
            })
            .catch(err => {
              console.error('添加咨询记录失败', err)
              wx.hideLoading()
              wx.showToast({
                title: '添加失败',
                icon: 'none'
              })
            })
        }
      })
      .catch(err => {
        console.error('获取申请记录失败', err);
        // 即使没有申请记录，也继续创建咨询记录
        
        // 获取当前登录用户信息（确保在catch块中也能使用）
        const currentUserInfo = wx.getStorageSync('userInfo');
        
        // 准备基本的表单数据
        const formData = {
          userId: this.data.selectedStudent._id,
          staffId: currentUserInfo._id || currentUserInfo.openId || currentUserInfo._openid,
          username: this.data.selectedStudent.username || this.data.selectedStudent.name,
          content: this.data.formData.content,
          conclusion: this.data.formData.conclusion,
          suggestion: this.data.formData.suggestion,
          location: this.data.formData.location || '心理咨询室',
          evaluationTime: this.data.formData.evaluationTime ? new Date(this.data.formData.evaluationTime) : new Date(),
          mentalStatus: this.data.formData.mentalStatus || '一般',
          notes: this.data.formData.notes || '',
          updateTime: new Date()
        }
        
        // 添加班级信息
        if (this.data.selectedStudent.classes && this.data.selectedStudent.classes.length > 0) {
          formData.class = this.data.selectedStudent.classes[0];
        } else if (this.data.selectedStudent.class) {
          formData.class = this.data.selectedStudent.class;
        }
        
        // 根据模式执行新增或更新操作
        if (this.data.isEditing) {
          db.collection('consultation_records')
            .doc(this.data.currentRecord._id)
            .update({
              data: formData
            })
            .then(() => {
              wx.hideLoading()
              wx.showToast({
                title: '更新成功',
              })
              this.setData({
                showEditModal: false
              })
              this.fetchRecords() // 刷新列表数据
            })
            .catch(err => {
              console.error('更新咨询记录失败', err)
              wx.hideLoading()
              wx.showToast({
                title: '更新失败',
                icon: 'none'
              })
            })
        } else {
          // 添加创建时间字段
          formData.createTime = new Date()
          
          // 新增记录
          db.collection('consultation_records')
            .add({
              data: formData
            })
            .then(() => {
              wx.hideLoading()
              wx.showToast({
                title: '添加成功',
              })
              this.setData({
                showEditModal: false
              })
              this.fetchRecords() // 刷新列表数据
            })
            .catch(err => {
              console.error('添加咨询记录失败', err)
              wx.hideLoading()
              wx.showToast({
                title: '添加失败',
                icon: 'none'
              })
            })
        }
      });
  }
})